home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / UndoDelegator.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  383 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import sys
  5. import string
  6. from Tkinter import *
  7. from Delegator import Delegator
  8.  
  9. class UndoDelegator(Delegator):
  10.     max_undo = 1000
  11.     
  12.     def __init__(self):
  13.         Delegator.__init__(self)
  14.         self.reset_undo()
  15.  
  16.     
  17.     def setdelegate(self, delegate):
  18.         if self.delegate is not None:
  19.             self.unbind('<<undo>>')
  20.             self.unbind('<<redo>>')
  21.             self.unbind('<<dump-undo-state>>')
  22.         
  23.         Delegator.setdelegate(self, delegate)
  24.         if delegate is not None:
  25.             self.bind('<<undo>>', self.undo_event)
  26.             self.bind('<<redo>>', self.redo_event)
  27.             self.bind('<<dump-undo-state>>', self.dump_event)
  28.         
  29.  
  30.     
  31.     def dump_event(self, event):
  32.         pprint = pprint
  33.         import pprint
  34.         pprint(self.undolist[:self.pointer])
  35.         print 'pointer:', self.pointer, 'saved:', self.saved, 'can_merge:', self.can_merge, 'get_saved():', self.get_saved()
  36.         pprint(self.undolist[self.pointer:])
  37.         return 'break'
  38.  
  39.     
  40.     def reset_undo(self):
  41.         self.was_saved = -1
  42.         self.pointer = 0
  43.         self.undolist = []
  44.         self.undoblock = 0
  45.         self.set_saved(1)
  46.  
  47.     
  48.     def set_saved(self, flag):
  49.         if flag:
  50.             self.saved = self.pointer
  51.         else:
  52.             self.saved = -1
  53.         self.can_merge = False
  54.         self.check_saved()
  55.  
  56.     
  57.     def get_saved(self):
  58.         return self.saved == self.pointer
  59.  
  60.     saved_change_hook = None
  61.     
  62.     def set_saved_change_hook(self, hook):
  63.         self.saved_change_hook = hook
  64.  
  65.     was_saved = -1
  66.     
  67.     def check_saved(self):
  68.         is_saved = self.get_saved()
  69.         if is_saved != self.was_saved:
  70.             self.was_saved = is_saved
  71.             if self.saved_change_hook:
  72.                 self.saved_change_hook()
  73.             
  74.         
  75.  
  76.     
  77.     def insert(self, index, chars, tags = None):
  78.         self.addcmd(InsertCommand(index, chars, tags))
  79.  
  80.     
  81.     def delete(self, index1, index2 = None):
  82.         self.addcmd(DeleteCommand(index1, index2))
  83.  
  84.     
  85.     def undo_block_start(self):
  86.         if self.undoblock == 0:
  87.             self.undoblock = CommandSequence()
  88.         
  89.         self.undoblock.bump_depth()
  90.  
  91.     
  92.     def undo_block_stop(self):
  93.         if self.undoblock.bump_depth(-1) == 0:
  94.             cmd = self.undoblock
  95.             self.undoblock = 0
  96.             if len(cmd) > 0:
  97.                 if len(cmd) == 1:
  98.                     cmd = cmd.getcmd(0)
  99.                 
  100.                 self.addcmd(cmd, 0)
  101.             
  102.         
  103.  
  104.     
  105.     def addcmd(self, cmd, execute = True):
  106.         if execute:
  107.             cmd.do(self.delegate)
  108.         
  109.         if self.undoblock != 0:
  110.             self.undoblock.append(cmd)
  111.             return None
  112.         
  113.         if self.can_merge and self.pointer > 0:
  114.             lastcmd = self.undolist[self.pointer - 1]
  115.             if lastcmd.merge(cmd):
  116.                 return None
  117.             
  118.         
  119.         self.undolist[self.pointer:] = [
  120.             cmd]
  121.         if self.saved > self.pointer:
  122.             self.saved = -1
  123.         
  124.         self.pointer = self.pointer + 1
  125.         if len(self.undolist) > self.max_undo:
  126.             del self.undolist[0]
  127.             self.pointer = self.pointer - 1
  128.             if self.saved >= 0:
  129.                 self.saved = self.saved - 1
  130.             
  131.         
  132.         self.can_merge = True
  133.         self.check_saved()
  134.  
  135.     
  136.     def undo_event(self, event):
  137.         if self.pointer == 0:
  138.             self.bell()
  139.             return 'break'
  140.         
  141.         cmd = self.undolist[self.pointer - 1]
  142.         cmd.undo(self.delegate)
  143.         self.pointer = self.pointer - 1
  144.         self.can_merge = False
  145.         self.check_saved()
  146.         return 'break'
  147.  
  148.     
  149.     def redo_event(self, event):
  150.         if self.pointer >= len(self.undolist):
  151.             self.bell()
  152.             return 'break'
  153.         
  154.         cmd = self.undolist[self.pointer]
  155.         cmd.redo(self.delegate)
  156.         self.pointer = self.pointer + 1
  157.         self.can_merge = False
  158.         self.check_saved()
  159.         return 'break'
  160.  
  161.  
  162.  
  163. class Command:
  164.     tags = None
  165.     
  166.     def __init__(self, index1, index2, chars, tags = None):
  167.         self.marks_before = { }
  168.         self.marks_after = { }
  169.         self.index1 = index1
  170.         self.index2 = index2
  171.         self.chars = chars
  172.         if tags:
  173.             self.tags = tags
  174.         
  175.  
  176.     
  177.     def __repr__(self):
  178.         s = self.__class__.__name__
  179.         t = (self.index1, self.index2, self.chars, self.tags)
  180.         if self.tags is None:
  181.             t = t[:-1]
  182.         
  183.         return s + repr(t)
  184.  
  185.     
  186.     def do(self, text):
  187.         pass
  188.  
  189.     
  190.     def redo(self, text):
  191.         pass
  192.  
  193.     
  194.     def undo(self, text):
  195.         pass
  196.  
  197.     
  198.     def merge(self, cmd):
  199.         return 0
  200.  
  201.     
  202.     def save_marks(self, text):
  203.         marks = { }
  204.         for name in text.mark_names():
  205.             if name != 'insert' and name != 'current':
  206.                 marks[name] = text.index(name)
  207.                 continue
  208.         
  209.         return marks
  210.  
  211.     
  212.     def set_marks(self, text, marks):
  213.         for name, index in marks.items():
  214.             text.mark_set(name, index)
  215.         
  216.  
  217.  
  218.  
  219. class InsertCommand(Command):
  220.     
  221.     def __init__(self, index1, chars, tags = None):
  222.         Command.__init__(self, index1, None, chars, tags)
  223.  
  224.     
  225.     def do(self, text):
  226.         self.marks_before = self.save_marks(text)
  227.         self.index1 = text.index(self.index1)
  228.         if text.compare(self.index1, '>', 'end-1c'):
  229.             self.index1 = text.index('end-1c')
  230.         
  231.         text.insert(self.index1, self.chars, self.tags)
  232.         self.index2 = text.index('%s+%dc' % (self.index1, len(self.chars)))
  233.         self.marks_after = self.save_marks(text)
  234.  
  235.     
  236.     def redo(self, text):
  237.         text.mark_set('insert', self.index1)
  238.         text.insert(self.index1, self.chars, self.tags)
  239.         self.set_marks(text, self.marks_after)
  240.         text.see('insert')
  241.  
  242.     
  243.     def undo(self, text):
  244.         text.mark_set('insert', self.index1)
  245.         text.delete(self.index1, self.index2)
  246.         self.set_marks(text, self.marks_before)
  247.         text.see('insert')
  248.  
  249.     
  250.     def merge(self, cmd):
  251.         if self.__class__ is not cmd.__class__:
  252.             return False
  253.         
  254.         if self.index2 != cmd.index1:
  255.             return False
  256.         
  257.         if self.tags != cmd.tags:
  258.             return False
  259.         
  260.         if len(cmd.chars) != 1:
  261.             return False
  262.         
  263.         if self.chars and self.classify(self.chars[-1]) != self.classify(cmd.chars):
  264.             return False
  265.         
  266.         self.index2 = cmd.index2
  267.         self.chars = self.chars + cmd.chars
  268.         return True
  269.  
  270.     alphanumeric = string.ascii_letters + string.digits + '_'
  271.     
  272.     def classify(self, c):
  273.         if c in self.alphanumeric:
  274.             return 'alphanumeric'
  275.         
  276.         if c == '\n':
  277.             return 'newline'
  278.         
  279.         return 'punctuation'
  280.  
  281.  
  282.  
  283. class DeleteCommand(Command):
  284.     
  285.     def __init__(self, index1, index2 = None):
  286.         Command.__init__(self, index1, index2, None, None)
  287.  
  288.     
  289.     def do(self, text):
  290.         self.marks_before = self.save_marks(text)
  291.         self.index1 = text.index(self.index1)
  292.         if self.index2:
  293.             self.index2 = text.index(self.index2)
  294.         else:
  295.             self.index2 = text.index(self.index1 + ' +1c')
  296.         if text.compare(self.index2, '>', 'end-1c'):
  297.             self.index2 = text.index('end-1c')
  298.         
  299.         self.chars = text.get(self.index1, self.index2)
  300.         text.delete(self.index1, self.index2)
  301.         self.marks_after = self.save_marks(text)
  302.  
  303.     
  304.     def redo(self, text):
  305.         text.mark_set('insert', self.index1)
  306.         text.delete(self.index1, self.index2)
  307.         self.set_marks(text, self.marks_after)
  308.         text.see('insert')
  309.  
  310.     
  311.     def undo(self, text):
  312.         text.mark_set('insert', self.index1)
  313.         text.insert(self.index1, self.chars)
  314.         self.set_marks(text, self.marks_before)
  315.         text.see('insert')
  316.  
  317.  
  318.  
  319. class CommandSequence(Command):
  320.     
  321.     def __init__(self):
  322.         self.cmds = []
  323.         self.depth = 0
  324.  
  325.     
  326.     def __repr__(self):
  327.         s = self.__class__.__name__
  328.         strs = []
  329.         for cmd in self.cmds:
  330.             strs.append('    %r' % (cmd,))
  331.         
  332.         return s + '(\n' + ',\n'.join(strs) + '\n)'
  333.  
  334.     
  335.     def __len__(self):
  336.         return len(self.cmds)
  337.  
  338.     
  339.     def append(self, cmd):
  340.         self.cmds.append(cmd)
  341.  
  342.     
  343.     def getcmd(self, i):
  344.         return self.cmds[i]
  345.  
  346.     
  347.     def redo(self, text):
  348.         for cmd in self.cmds:
  349.             cmd.redo(text)
  350.         
  351.  
  352.     
  353.     def undo(self, text):
  354.         cmds = self.cmds[:]
  355.         cmds.reverse()
  356.         for cmd in cmds:
  357.             cmd.undo(text)
  358.         
  359.  
  360.     
  361.     def bump_depth(self, incr = 1):
  362.         self.depth = self.depth + incr
  363.         return self.depth
  364.  
  365.  
  366.  
  367. def main():
  368.     Percolator = Percolator
  369.     import Percolator
  370.     root = Tk()
  371.     root.wm_protocol('WM_DELETE_WINDOW', root.quit)
  372.     text = Text()
  373.     text.pack()
  374.     text.focus_set()
  375.     p = Percolator(text)
  376.     d = UndoDelegator()
  377.     p.insertfilter(d)
  378.     root.mainloop()
  379.  
  380. if __name__ == '__main__':
  381.     main()
  382.  
  383.